////////////////////////////////////////////////
//	File			:	"Messages.h"
//
//	Author			:	Steven Seufert (SMS)
//			
//	Last Modified	:	January 18, 2012
//
//	Purpose			:	To define all messages used by the message system
/////////////////////////////////////////////////
#ifndef MESSAGES_H
#define MESSAGES_H

typedef int MSGID;
enum {
	MSG_CREATE_PLAYER,
	MSG_DESTROY_PLAYER, 
	//spells 
	// Traps
	MSG_CREATE_PROXRUNE, 
	MSG_DESTROY_PROXRUNE,
	MSG_CREATE_REMOTERUNE, 
	MSG_DESTROY_REMOTERUNE, 
	MSG_CREATE_DECOY,
	MSG_DESTROY_DECOY,
	MSG_CREATE_BARRIER,
	MSG_DESTROY_BARRIER,
	// Evocation
	MSG_CREATE_FIREBALL,
	MSG_DESTROY_FIREBALL,
	MSG_CREATE_FROSTSPRAY_BULLET,
	MSG_DESTROY_FROSTSPRAY_BULLET,
	MSG_CREATE_ICEBLAST,
	MSG_DESTROY_ICEBLAST,
	// Restoration
	MSG_CREATE_HEALALLY,
	MSG_DESTROY_HEALALLY,
	MSG_CREATE_MANAGIFT,
	MSG_DESTROY_MANAGIFT,
	MSG_CREATE_HEALCIRCLE,
	MSG_DESTROY_HEALCIRCLE,
	// Transmutation
	MSG_CREATE_FORTIFYALLY,
	MSG_DESTROY_FORTIFYALLY,
	MSG_CREATE_EMPOWER,
	MSG_DESTROY_EMPOWER,
	// Necromancy
	MSG_CREATE_RAISEDEAD,
	MSG_DESTROY_RAISEDEAD,
	MSG_CREATE_LIFEDRAIN_BULLET,
	MSG_DESTROY_LIFEDRAIN_BULLET,
	MSG_CREATE_PLAGUE,
	MSG_DESTROY_PLAGUE,
	MSG_CREATE_FEARSYMBOL,
	MSG_DESTROY_FEARSYMBOL,
};


//forward declarations
class CPlayer;
class CProximityRune;
class CRemoteRune;
class CDecoy;
class CBarrier;
class CFireball;
class CFrostSpray;
class CIceBlast;
class CHealAlly;
class CManaGift;
class CHealingCircle;
class CFortifyAlly;
class CEmpower;
class CRaiseDead;
class CLifeDrain;
class CPlague;
class CSymbolOfFear;

class CBaseMessage
{
private:
	MSGID	m_msgID;

protected:
	enum {MSG_BLACK, MSG_WHITE};

public:
	CBaseMessage(MSGID msgID)
	{
		m_msgID = msgID;
	}

	virtual ~CBaseMessage(void) {}

	MSGID GetMsgID(void)	{ return m_msgID; }
};
///////////////////////////
//	Player
///////////////////////////
class CCreatePlayerMsg : public CBaseMessage
{
private:	
	int		m_nPlayerNum;
	int		m_nPosX;
	int		m_nPosY;
public:
	CCreatePlayerMsg(int posX, int posY);

	int GetPosX() const	{ return m_nPosX; }
	int GetPosY() const	{ return m_nPosY; }
};

class CDestroyPlayerMsg : public CBaseMessage
{
private:
	CPlayer*		m_pPlayer;
public:
	// constructor
	CDestroyPlayerMsg(CPlayer* pParamPlayer);

	// destructor
	~CDestroyPlayerMsg();

	CPlayer*		GetPlayer() const { return m_pPlayer; }
};

///////////////////////////
//	Proximity Rune
///////////////////////////
class CCreateProxRuneMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
public:
	CCreateProxRuneMsg(int posX, int posY);

	int GetPosX() const	{ return m_nPosX; }
	int GetPosY() const	{ return m_nPosY; }
};

class CDestroyProxRuneMsg : public CBaseMessage
{
private:
	CProximityRune*		m_pRune;
public:
	// constructor
	CDestroyProxRuneMsg(CProximityRune* pParamRune);

	// destructor
	~CDestroyProxRuneMsg();

	CProximityRune*		GetProxRune() const { return m_pRune; }
};

///////////////////////////
//	Remote Rune
///////////////////////////
class CCreateRemoteRuneMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
public:
	CCreateRemoteRuneMsg(int posX, int posY);

	int GetPosX() const	{ return m_nPosX; }
	int GetPosY() const	{ return m_nPosY; }
};

class CDestroyRemoteRuneMsg : public CBaseMessage
{
private:
	CRemoteRune*		m_pRune;
public:
	// constructor
	CDestroyRemoteRuneMsg(CRemoteRune* pParamRune);

	// destructor
	~CDestroyRemoteRuneMsg();

	CRemoteRune*		GetRemoteRune() const { return m_pRune; }
};

///////////////////////////
//	Decoy
///////////////////////////
class CCreateDecoyMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
public:
	CCreateDecoyMsg(int posX, int posY);

	int GetPosX() const	{ return m_nPosX; }
	int GetPosY() const	{ return m_nPosY; }
};

class CDestroyDecoyMsg : public CBaseMessage
{
private:
	CDecoy*		m_pDecoy;
public:
	// constructor
	CDestroyDecoyMsg(CDecoy* pParamDecoy);

	// destructor
	~CDestroyDecoyMsg();

	CDecoy*		GetDecoy() const { return m_pDecoy; }
};

///////////////////////////
//	Barrier
///////////////////////////
class CCreateBarrierMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
public:
	CCreateBarrierMsg(int posX, int posY);

	int GetPosX() const	{ return m_nPosX; }
	int GetPosY() const	{ return m_nPosY; }
};

class CDestroyBarrierMsg : public CBaseMessage
{
private:
	CBarrier*		m_pBarrier;
public:
	// constructor
	CDestroyBarrierMsg(CBarrier* pParamBarrier);

	// destructor
	~CDestroyBarrierMsg();

	CBarrier*		GetBarrier() const { return m_pBarrier; }
};


///////////////////////////
//	Fireball
///////////////////////////
class CCreateFireballMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateFireballMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const	{ return m_nPosX; }
	int GetPosY() const	{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyFireballMsg : public CBaseMessage
{
private:
	CFireball*		m_pFireball;
public:
	// constructor
	CDestroyFireballMsg(CFireball* pParamFireball);

	// destructor
	~CDestroyFireballMsg();

	CFireball*		GetFireball() const { return m_pFireball; }
};

///////////////////////////
//	Frost Spray
///////////////////////////
class CCreateFrostSprayMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateFrostSprayMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyFrostSprayMsg : public CBaseMessage
{
private:
	CFrostSpray*		m_pFrostSpray;
public:
	// constructor
	CDestroyFrostSprayMsg(CFrostSpray* pParamFrostSpray);

	// destructor
	~CDestroyFrostSprayMsg();

	CFrostSpray*		GetFrostSpray() const { return m_pFrostSpray; }
};

///////////////////////////
//	Ice Blast
///////////////////////////
class CCreateIceBlastMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateIceBlastMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyIceBlastMsg : public CBaseMessage
{
private:
	CIceBlast*		m_pIceBlast;
public:
	// constructor
	CDestroyIceBlastMsg(CIceBlast* pParamIceBlast);

	// destructor
	~CDestroyIceBlastMsg();

	CIceBlast*		GetIceBlast() const { return m_pIceBlast; }
};

///////////////////////////
//	Heal Ally
///////////////////////////
class CCreateHealAllyMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateHealAllyMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyHealAllyMsg : public CBaseMessage
{
private:
	CHealAlly*		m_pHealAlly;
public:
	// constructor
	CDestroyHealAllyMsg(CHealAlly* pParamHealAlly);

	// destructor
	~CDestroyHealAllyMsg();

	CHealAlly*		GetHealAlly() const { return m_pHealAlly; }
};

///////////////////////////
//	Mana Gift
///////////////////////////
class CCreateManaGiftMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateManaGiftMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyManaGiftMsg : public CBaseMessage
{
private:
	CManaGift*		m_pManaGift;
public:
	// constructor
	CDestroyManaGiftMsg(CManaGift* pParamManaGift);

	// destructor
	~CDestroyManaGiftMsg();

	CManaGift*		GetManaGift() const { return m_pManaGift; }
};

///////////////////////////
//	Healing Circle
///////////////////////////
class CCreateHealingCircleMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
public:
	CCreateHealingCircleMsg(int posX, int posY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
};

class CDestroyHealingCircleMsg : public CBaseMessage
{
private:
	CHealingCircle*		m_pHealingCircle;
public:
	// constructor
	CDestroyHealingCircleMsg(CHealingCircle* pParamHealingCircle);

	// destructor
	~CDestroyHealingCircleMsg();

	CHealingCircle*		GetHealingCircle() const { return m_pHealingCircle; }
};

///////////////////////////
//	Fortify Ally
///////////////////////////
class CCreateFortifyAllyMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateFortifyAllyMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyFortifyAllyMsg : public CBaseMessage
{
private:
	CFortifyAlly*		m_pFortifyAlly;
public:
	// constructor
	CDestroyFortifyAllyMsg(CFortifyAlly* pParamFortifyAlly);

	// destructor
	~CDestroyFortifyAllyMsg();

	CFortifyAlly*		GetFortifyAlly() const { return m_pFortifyAlly; }
};

///////////////////////////
//	Empower
///////////////////////////
class CCreateEmpowerMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateEmpowerMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyEmpowerMsg : public CBaseMessage
{
private:
	CEmpower*		m_pEmpower;
public:
	// constructor
	CDestroyEmpowerMsg(CEmpower* pParamEmpower);

	// destructor
	~CDestroyEmpowerMsg();

	CEmpower*		GetEmpower() const { return m_pEmpower; }
};

///////////////////////////
//	Raise Dead
///////////////////////////
class CCreateRaiseDeadMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateRaiseDeadMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyRaiseDeadMsg : public CBaseMessage
{
private:
	CRaiseDead*		m_pRaiseDead;
public:
	// constructor
	CDestroyRaiseDeadMsg(CRaiseDead* pParamRaiseDead);

	// destructor
	~CDestroyRaiseDeadMsg();

	CRaiseDead*		GetRaiseDead() const { return m_pRaiseDead; }
};

///////////////////////////
//	Life Drain
///////////////////////////
class CCreateLifeDrainMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreateLifeDrainMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyLifeDrainMsg : public CBaseMessage
{
private:
	CLifeDrain*		m_pLifeDrain;
public:
	// constructor
	CDestroyLifeDrainMsg(CLifeDrain* pParamLifeDrain);

	// destructor
	~CDestroyLifeDrainMsg();

	CLifeDrain*		GetLifeDrain() const { return m_pLifeDrain; }
};

///////////////////////////
//	Plague
///////////////////////////
class CCreatePlagueMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
	float	m_fVelX;
	float	m_fVelY;
public:
	CCreatePlagueMsg(int posX, int posY, float velX, float velY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
	float GetVelX() const	{ return m_fVelX; }
	float GetVelY() const	{ return m_fVelY; }
};

class CDestroyPlagueMsg : public CBaseMessage
{
private:
	CPlague*		m_pPlague;
public:
	// constructor
	CDestroyPlagueMsg(CPlague* pParamPlague);

	// destructor
	~CDestroyPlagueMsg();

	CPlague*		GetLifeDrain() const { return m_pPlague; }
};


///////////////////////////
//	Symbol of Fear
///////////////////////////
class CCreateSymbolOfFearMsg : public CBaseMessage
{
private:	
	int		m_nPosX;
	int		m_nPosY;
public:
	CCreateSymbolOfFearMsg(int posX, int posY);

	int GetPosX() const		{ return m_nPosX; }
	int GetPosY() const		{ return m_nPosY; }
};

class CDestroySymbolOfFearMsg : public CBaseMessage
{
private:
	CSymbolOfFear*		m_pSymbolOfFear;
public:
	// constructor
	CDestroySymbolOfFearMsg(CSymbolOfFear* pParamSymbolOfFear);

	// destructor
	~CDestroySymbolOfFearMsg();

	CSymbolOfFear*		GetLifeDrain() const { return m_pSymbolOfFear; }
};
#endif